TypeScript 的類別基礎

在 TypeScript 中，類別（Classes）提供了一個面向對象編程的方式，讓我們能夠更有效地組織和重用程式碼。類別不僅可以定義物件的結構，還可以包含行為邏輯，從而建立更具模組化的程式設計模式。TypeScript 加強了 JavaScript 的類別功能，提供了型別檢查和其他強大的功能，讓我們能夠更安全地編寫程式。

1. 基本類別定義

類別的定義與 JavaScript 類似，但 TypeScript 讓我們可以指定元素的型別並進行更嚴格的型別檢查。以下是一個簡單的類別範例：

// 定義一個類別
class Person {
    name: string;
    age: number;

    constructor(name: string, age: number) {
        this.name = name;
        this.age = age;
    }

    greet(): string {
        return `Hello, my name is ${this.name} and I am ${this.age} years old.`;
    }
}

// 使用類別來創建物件
const person = new Person("John", 30);
console.log(person.greet()); // Hello, my name is John and I am 30 years old.

在這個範例中，我們定義了一個 Person 類別，這個類別有兩個屬性 name 和 age，以及一個方法 greet。類別的建構函式（constructor）用來初始化物件的屬性。

2. 存取修飾符（Access Modifiers）

TypeScript 支援三種主要的存取修飾符，分別是 public、private 和 protected，用來控制類別元素的可見性。

• public: 預設情況下，類別的元素都是 public，可以從類別內外存取。
• private: private 元素只能在類別內部存取，外部無法直接存取。
• protected: protected 元素只能在類別內部或其子類別中存取，無法從外部直接存取。

以下範例展示了不同的存取修飾符應用：

// 使用存取修飾符
class Employee {
    public name: string;
    private salary: number;
    protected position: string;

    constructor(name: string, salary: number, position: string) {
        this.name = name;
        this.salary = salary;
        this.position = position;
    }

    public getDetails(): string {
        return `${this.name} is a ${this.position}.`;
    }

    private calculateBonus(): number {
        return this.salary * 0.1;
    }
}

const employee = new Employee("Annie", 1000000, "Developer");
console.log(employee.getDetails());  // Annie is a Developer
console.log(employee.salary);      // Error: Property 'salary' is private
console.log(employee.calculateBonus()); // Error: Method 'calculateBonus' is private

在這個例子中，name 是 public 元素，可以在類別外部存取；salary 是 private 元素，只有在類別內部才能存取；position 是 protected 元素，子類別可以存取，但外部無法存取。

3. 繼承（Inheritance）

TypeScript 支援類別的繼承，這讓我們可以基於現有類別另外擴展功能。透過 extends 關鍵字，我們可以建立一個子類別來繼承父類別的屬性和方法：

// 定義父類別
class Animal {
    species: string;

    constructor(species: string) {
        this.species = species;
    }

    sound(): string {
        return `${this.species} makes a sound.`;
    }
}

// 定義子類別
class Cat extends Animal {
    constructor() {
        super("Cat");
    }

    sound(): string {
        return `${this.species} meow.`;
    }
}

const dog = new Cat();
console.log(dog.sound()); // Cat meow.

在這個範例裡，Cat 類別繼承了 Animal 類別，並覆寫了 sound 方法。super 關鍵字用來呼叫父類別的建構函式。

4. 抽象類別（Abstract Classes）

抽象類別是不能被直接實例化的類別，只能被其他類別繼承。它們通常用來定義一個基礎類別，強制子類別實現某些方法。抽象類別可以包含抽象方法和具體方法：

// 定義抽象類別
abstract class Shape {
    abstract area(): number;

    describe(): string {
        return "This is a shape.";
    }
}

// 繼承抽象類別
class Circle extends Shape {
    radius: number;

    constructor(radius: number) {
        super();
        this.radius = radius;
    }

    area(): number {
        return Math.PI * this.radius * this.radius;
    }
}

const circle = new Circle(10);
console.log(circle.area()); // 314.159...
console.log(circle.describe()); // This is a shape.

在這裡，Shape 是一個抽象類別，它要求所有子類別必須實作 area 方法，這樣可以確保每個形狀都有自己計算面積的邏輯。

結語

TypeScript 的類別提供了強大的類別設計功能，透過型別檢查和存取控制，我們能夠寫出更安全和可維護的程式碼。類別的基礎概念，和存取修飾符、繼承和抽象類別等應用，都能夠幫助我們提升專案的靈活組織度和功能擴展性。